home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 5 / BBS in a Box -Volume V (BBS in a Box) (April 1992).iso / Files / Prog / M / Mac gperf 1.9.cpt / Mac gperf 1.9 / src / options.c / options.c
Encoding:
C/C++ Source or Header  |  1991-03-21  |  18.6 KB  |  494 lines  |  [TEXT/KAHL]
  1. /* Handles parsing the Options provided to the user.
  2.    Copyright (C) 1989 Free Software Foundation, Inc.
  3.    written by Douglas C. Schmidt (schmidt@ics.uci.edu)
  4.  
  5. This file is part of GNU GPERF.
  6.  
  7. GNU GPERF is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 1, or (at your option)
  10. any later version.
  11.  
  12. GNU GPERF is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU GPERF; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <assert.h>
  24.  
  25. #include "gperf.h"
  26. #include "iterator.h"
  27. #include "stderr.h"
  28. #include "getopt.h"
  29.  
  30. #include "options.h"
  31.  
  32. /* Size to jump on a collision. */
  33. #define DEFAULT_JUMP_VALUE 5
  34.  
  35. /* Default name for generated lookup function. */
  36. #define DEFAULT_NAME "in_word_set"
  37.  
  38. /* Default name for the key component. */
  39. #define DEFAULT_KEY "name"
  40.  
  41. /* Default name for generated hash function. */
  42. #define DEFAULT_HASH_NAME "hash"
  43.  
  44. /* Globally visible OPTIONS object. */
  45. OPTIONS option;
  46.  
  47.     /**  File pointer for keyword file  **/
  48.  
  49. FILE *    KeyFile;
  50.  
  51. /*******************************************************************************\
  52. *                              Prototypes                                        *
  53. \*******************************************************************************/
  54.  
  55. static int    key_sort( char * base, int len );
  56.  
  57. void        usage( void );
  58. void        options_destroy( void );
  59. void        options_init( int argc, char *argv[] );
  60.  
  61.  
  62.     /***********************************************************************\
  63.     *                                                                        *
  64.     * name:        usage                                                        *
  65.     *                                                                        *
  66.     * descr:    Prints program usage to standard error stream.                *
  67.     *                                                                        *
  68.     \***********************************************************************/
  69.  
  70. void usage()
  71. { 
  72.   report_error ("usage: %n [-acCdDf[num]gGhH<hashname>i<init>jk<keys>K<keyname>lnN<name>oprs<size>StTv].\n(type %n -h for help)\n");
  73. }
  74.  
  75.     /***********************************************************************\
  76.     *                                                                        *
  77.     * name:        key_sort                                                    *
  78.     *                                                                        *
  79.     * descr:    Sorts the key positions IN REVERSE ORDER. This makes         *
  80.     *            further routines more efficient, especially when             *
  81.     *            generating code. Uses a simple insertion sort since the     *
  82.     *            set is probably already order. Returns 1 if there are no    *
  83.     *            duplicates, 0 otherwise.                                    *
  84.     *                                                                        *
  85.     \***********************************************************************/
  86.  
  87. static int key_sort( char * base, int len )
  88. {
  89.   int i, j;
  90.  
  91.   for (i = 0, j = len - 1; i < j; i++) 
  92.     {
  93.       int curr, tmp;
  94.       
  95.       for (curr = i + 1,tmp = base[curr]; curr > 0 && tmp >= base[curr - 1]; curr--) 
  96.         if ((base[curr] = base[curr - 1]) == tmp) /* oh no, a duplicate!!! */
  97.           return 0;
  98.  
  99.       base[curr] = tmp;
  100.     }
  101.  
  102.   return 1;
  103. }
  104.  
  105.  
  106.     /***********************************************************************\
  107.     *                                                                        *
  108.     * name:        options_destroy                                                *
  109.     *                                                                        *
  110.     * descr:    Dumps option status when debug is set.                        *
  111.     *                                                                        *
  112.     \***********************************************************************/
  113.  
  114. void options_destroy()
  115. { 
  116.   if (OPTION_ENABLED (option, DEBUG))
  117.     {
  118.         fprintf (stderr, "\ndumping Options:\nDEBUG is.......: %s\nORDER is.......: %s\
  119. \nANSI is........: %s\nTYPE is........: %s\nGNU is.........: %s\nRANDOM is......: %s\
  120. \nDEFAULTCHARS is: %s\nSWITCH is......: %s\nPOINTER is.....: %s\nNOLENGTH is....: %s\n",
  121.                OPTION_ENABLED (option, DEBUG) ? "enabled" : "disabled", 
  122.                OPTION_ENABLED (option, ORDER) ? "enabled" : "disabled",
  123.                OPTION_ENABLED (option, ANSI) ? "enabled" : "disabled",
  124.                OPTION_ENABLED (option, TYPE) ? "enabled" : "disabled",
  125.                OPTION_ENABLED (option, GNU) ? "enabled" : "disabled",
  126.                OPTION_ENABLED (option, RANDOM) ? "enabled" : "disabled",
  127.                OPTION_ENABLED (option, DEFAULTCHARS) ? "enabled" : "disabled",
  128.                OPTION_ENABLED (option, SWITCH) ? "enabled" : "disabled",
  129.                OPTION_ENABLED (option, POINTER) ? "enabled" : "disabled",
  130.                OPTION_ENABLED (option, NOLENGTH) ? "enabled" : "disabled" );
  131.  
  132.         fprintf( stderr, "\
  133. \nLENTABLE is....: %s\nDUP is.........: %s\nCOMP is........: %s\nFAST is........: %s\
  134. \nNOTYPE is....: %s\nGLOBAL is.........: %s\nCONST is.........: %s\niterations = %d\
  135. \nlookup function name = %s\nhash function name = %s\nkey name = %s\
  136. \njump value = %d\nmax associcated value = %d\ninitial associated value = %d\n",
  137.                OPTION_ENABLED (option, LENTABLE) ? "enabled" : "disabled",
  138.                OPTION_ENABLED (option, DUP) ? "enabled" : "disabled",
  139.                OPTION_ENABLED (option, COMP) ? "enabled" : "disabled",
  140.                OPTION_ENABLED (option, FAST) ? "enabled" : "disabled",
  141.                OPTION_ENABLED (option, NOTYPE) ? "enabled" : "disabled",
  142.                OPTION_ENABLED (option, GLOBAL) ? "enabled" : "disabled",
  143.                OPTION_ENABLED (option, CONST) ? "enabled" : "disabled",
  144.                option.iterations, option.function_name, option.hash_name,
  145.                option.key_name, option.jump, option.size - 1, option.initial_asso_value);
  146.  
  147.         if ( OPTION_ENABLED( option, ALLCHARS ) ) 
  148.             fprintf( stderr, "all characters are used in the hash function\n" );
  149.         else 
  150.         {       
  151.             char *        ptr;
  152.  
  153.             fprintf( stderr, "total key positions = %d\nkey positions are: \n",
  154.                             option.total_key_positions );
  155.  
  156.             for ( ptr = option.key_positions; *ptr != EOS; ptr++ ) 
  157.                 if ( *ptr == WORD_END ) 
  158.                     fprintf( stderr, "$\n" );
  159.                 else 
  160.                     fprintf( stderr, "%d\n", *ptr );
  161.  
  162.             fprintf( stderr, "finished dumping Options\n" );
  163.         }
  164.     }
  165. }
  166.  
  167.  
  168.     /***********************************************************************\
  169.     *                                                                        *
  170.     * name:        options_init                                                *
  171.     *                                                                        *
  172.     * descr:    Parses the command line options and sets appropriate         *
  173.     *            flags in option.option_word.                                *
  174.     *                                                                        *
  175.     \***********************************************************************/
  176.  
  177. void options_init( int argc, char *argv[] )
  178. { 
  179.     int   option_char;
  180.  
  181.     option.key_positions[0]        = WORD_START;
  182.     option.key_positions[1]        = WORD_END;
  183.     option.key_positions[2]        = EOS;
  184.     option.total_key_positions    = 2;
  185.     option.jump                    = DEFAULT_JUMP_VALUE;
  186.     option.option_word            = (int) DEFAULTCHARS;
  187.     option.function_name        = DEFAULT_NAME;
  188.     option.hash_name            = DEFAULT_HASH_NAME;
  189.     option.key_name                = DEFAULT_KEY;
  190.     option.initial_asso_value    = option.size = option.iterations = 0;
  191.     set_program_name (argv[0]);
  192.     option.argument_count        = argc;
  193.     option.argument_vector        = argv;
  194.   
  195.     while ((option_char = getopt (argc, argv, "adcCDf:gGhH:i:j:k:K:lnN:oprs:StTv")) != EOF) 
  196.     {
  197.         switch (option_char)
  198.         {
  199.         case 'a':               /* Generated coded uses the ANSI prototype format. */
  200.           { 
  201.             SET_OPTION (option, ANSI);
  202.             break;
  203.           }
  204.         case 'c':               /* Generate strncmp rather than strcmp. */
  205.           {
  206.             SET_OPTION (option, COMP);
  207.             break;
  208.           }
  209.         case 'C':               /* Make the generated tables readonly (const). */
  210.           {
  211.             SET_OPTION (option, CONST);
  212.             break;
  213.           }
  214.         case 'd':               /* Enable debugging option. */
  215.           { 
  216.             SET_OPTION (option, DEBUG);
  217.             report_error ("starting program %n, version %s, with debugging on.\n",
  218.                           version_string);
  219.             break;
  220.           }   
  221.         case 'D':               /* Enable duplicate option. */
  222.           { 
  223.             SET_OPTION (option, DUP);
  224.             break;
  225.           }   
  226.         case 'f':               /* Generate the hash table ``fast.'' */
  227.           {
  228.             SET_OPTION (option, FAST);
  229.             if ((option.iterations = atoi (optarg)) < 0) 
  230.               {
  231.                 report_error ("iterations value must not be negative, assuming 0\n");
  232.                 option.iterations = 0;
  233.               }
  234.             break;
  235.           }
  236.         case 'g':               /* Use the ``inline'' keyword for generated sub-routines. */
  237.           { 
  238.             SET_OPTION (option, GNU);
  239.             break;
  240.           }
  241.         case 'G':               /* Make the keyword table a global variable. */
  242.           { 
  243.             SET_OPTION (option, GLOBAL);
  244.             break;
  245.           }
  246.         case 'h':               /* Displays a list of helpful Options to the user. */
  247.           { 
  248.         report_error(
  249.             "-a\tGenerate ANSI standard C output code, i.e., function prototypes.\n"
  250.             "-c\tGenerate comparison code using strncmp rather than strcmp.\n"
  251.             "-C\tMake the contents of generated lookup tables constant, i.e., readonly.\n"
  252.             "-d\tEnables the debugging option (produces verbose output to Std_Err).\n"
  253.             "-D\tHandle keywords that hash to duplicate values.  This is useful\n"
  254.               "\tfor certain highly redundant keyword sets.  It enables the -S option.\n"
  255.                           );
  256.  
  257.         report_error(
  258.             "-f\tGenerate the perfect hash function ``fast.''  This decreases GPERF's\n"
  259.               "\trunning time at the cost of minimizing generated table-size.\n"
  260.               "\tThe numeric argument represents the number of times to iterate when\n"
  261.               "\tresolving a collision.  `0' means ``iterate by the number of keywords''.\n"
  262.             "-g\tAssume a GNU compiler, e.g., g++ or gcc.  This makes all generated\n"
  263.               "\troutines use the ``inline'' keyword to remove cost of function calls.\n"
  264.                           );
  265.  
  266.         report_error(
  267.             "-G\tGenerate the static table of keywords as a static global variable,\n"
  268.               "\trather than hiding it inside of the lookup function (which is the\n"
  269.               "\tdefault behavior).\n"
  270.             "-h\tPrints this mesage.\n"
  271.             "-H\tAllow user to specify name of generated hash function. Default\n"
  272.               "\tis `hash'.\n"
  273.                           );
  274.  
  275.         report_error(
  276.             "-i\tProvide an initial value for the associate values array.  Default is 0.\n"
  277.               "\tSetting this value larger helps inflate the size of the final table.\n"
  278.             "-j\tAffects the ``jump value,'' i.e., how far to advance the associated\n"
  279.               "\tcharacter value upon collisions.  Must be an odd number, default is %d.\n",
  280.                       DEFAULT_JUMP_VALUE );
  281.  
  282.         report_error(
  283.             "-k\tAllows selection of the key positions used in the hash function.\n"
  284.               "\tThe allowable choices range between 1-%d, inclusive.  The positions\n"
  285.               "\tare separated by commas, ranges may be used, and key positions may\n"
  286.               "\toccur in any order.  Also, the meta-character '*' causes the generated\n"
  287.               "\thash function to consider ALL key positions, and $ indicates the\n"
  288.               "\t``final character'' of a key, e.g., $,1,2,4,6-10.\n",
  289.                     (MAX_KEY_POS - 1) );
  290.  
  291.         report_error(
  292.             "-K\tAllow user to select name of the keyword component in the keyword structure.\n"
  293.             "-l\tCompare key lengths before trying a string comparison.  This helps\n"
  294.               "\tcut down on the number of string comparisons made during the lookup.\n",
  295.             "-n\tDo not include the length of the keyword when computing the hash function\n"
  296.             "-N\tAllow user to specify name of generated lookup function.  Default\n"
  297.               "\tname is `in_word_set.'\n"
  298.                           );
  299.  
  300.         report_error(
  301.             "-o\tReorders input keys by frequency of occurrence of the key sets.\n"
  302.               "\tThis should decrease the search time dramatically.\n"
  303.             "-p\tChanges the return value of the generated function ``in_word_set''\n"
  304.               "\tfrom its default boolean value (i.e., 0 or 1), to type ``pointer\n"
  305.               "\tto wordlist array''  This is most useful when the -t option, allowing\n"
  306.               "\tuser-defined structs, is used.\n"
  307.             "-r\tUtilizes randomness to initialize the associated values table.\n"
  308.                           );
  309.  
  310.         report_error(
  311.             "-s\tAffects the size of the generated hash table.  The numeric argument\n"
  312.               "\tfor this option indicates ``how many times larger'' the table range\n"
  313.               "\tshould be, in relationship to the number of keys, e.g. a value of 3\n"
  314.               "\tmeans ``make the table about 3 times larger than the number of input\n"
  315.               "\tkeys.''  A larger table should decrease the time required for an\n"
  316.               "\tunsuccessful search, at the expense of extra table space.  Default\n"
  317.               "\tvalue is 1.  This actual table size may vary somewhat.\n"
  318.                           );
  319.  
  320.         report_error(
  321.             "-S\tCauses the generated C code to use a switch statement scheme, rather\n"
  322.               "\tthan an array lookup table.  This potentially saves *much* space, at\n"
  323.               "\tthe expense of longer time for each lookup.  Mostly important for\n"
  324.               "\t*large* input sets, i.e., greater than around 100 items or so.\n"
  325.             "-t\tAllows the user to include a structured type declaration for \n"
  326.               "\tgenerated code. Any text before %%%% is consider part of the type\n"
  327.               "\tdeclaration.  Key words and additional fields may follow this, one\n"
  328.               "\tgroup of fields per line.\n"
  329.                           );
  330.  
  331.         report_error(
  332.             "-T\tPrevents the transfer of the type declaration to the output file.\n"
  333.               "\tUse this option if the type is already defined elsewhere.\n"
  334.             "-v\tPrints out the current version number\n%e%a\n",
  335.                     usage );
  336.           }
  337.         case 'H':               /* Sets the name for the hash function */
  338.           {
  339.             option.hash_name = optarg;
  340.             break;
  341.           }
  342.         case 'i':               /* Sets the initial value for the associated values array. */
  343.           { 
  344.             if ((option.initial_asso_value = atoi (optarg)) < 0) 
  345.               report_error ("initial value %d must be non-zero, ignoring and continuing\n", option.initial_asso_value);
  346.             break;
  347.           }
  348.         case 'j':               /* Sets the jump value, must be odd for later algorithms. */
  349.           { 
  350.             if ((option.jump = atoi (optarg)) <= 0) 
  351.               report_error ("jump value %d must be a positive number\n%e%a", option.jump, usage);
  352.             else if (EVEN (option.jump)) 
  353.               report_error ("jump value %d should be odd, adding 1 and continuing...\n", option.jump++);
  354.             break;
  355.           }
  356.         case 'k':               /* Sets key positions used for hash function. */
  357.           { 
  358.             int BAD_VALUE = -1;
  359.             int value;
  360.  
  361.             iterator_init (optarg, 1, MAX_KEY_POS - 1, WORD_END, BAD_VALUE, EOS);
  362.             
  363.             if (*optarg == '*') /* Use all the characters for hashing!!!! */
  364.               {
  365.                 UNSET_OPTION (option, DEFAULTCHARS);
  366.                 SET_OPTION (option, ALLCHARS);
  367.               }
  368.             else 
  369.               {
  370.                 char *key_pos;
  371.  
  372.                 for (key_pos = option.key_positions; (value = next ()) != EOS; key_pos++)
  373.                   if (value == BAD_VALUE) 
  374.                     report_error ("illegal key value or range, use 1,2,3-%d,'$' or '*'.\n%e%a", (MAX_KEY_POS - 1),usage);
  375.                   else 
  376.                     *key_pos = value;;
  377.  
  378.                 *key_pos = EOS;
  379.  
  380.                 if (! (option.total_key_positions = (key_pos - option.key_positions))) 
  381.                   report_error ("no keys selected\n%e%a", usage);
  382.                 else if (! key_sort (option.key_positions, option.total_key_positions))
  383.                   report_error ("duplicate keys selected\n%e%a", usage);
  384.  
  385.                 if (option.total_key_positions != 2 
  386.                     || (option.key_positions[0] != 1 || option.key_positions[1] != WORD_END))
  387.                   UNSET_OPTION (option, DEFAULTCHARS);
  388.               }
  389.             break;
  390.           }
  391.         case 'K':               /* Make this the keyname for the keyword component field. */
  392.           {
  393.             option.key_name = optarg;
  394.             break;
  395.           }
  396.         case 'l':               /* Create length table to avoid extra string compares. */
  397.           { 
  398.             SET_OPTION (option, LENTABLE);
  399.             break;
  400.           }
  401.         case 'n':               /* Don't include the length when computing hash function. */
  402.           { 
  403.             SET_OPTION (option, NOLENGTH);
  404.             break; 
  405.           }
  406.         case 'N':               /* Make generated lookup function name be optarg */
  407.           { 
  408.             option.function_name = optarg;
  409.             break;
  410.           }
  411.         case 'o':               /* Order input by frequency of key set occurrence. */
  412.           { 
  413.             SET_OPTION (option, ORDER);
  414.             break;
  415.           }   
  416.         case 'p':               /* Generated lookup function now a pointer instead of int. */
  417.           { 
  418.             SET_OPTION (option, POINTER);
  419.             break;
  420.           }
  421.         case 'r':               /* Utilize randomness to initialize the associated values table. */
  422.           { 
  423.             SET_OPTION (option, RANDOM);
  424.             break;
  425.           }
  426.         case 's':               /* Range of associated values, determines size of final table. */
  427.           { 
  428.             if ((option.size = atoi (optarg)) <= 0) 
  429.               report_error ("improper range argument %s\n%e%a", optarg, usage);
  430.             else if (option.size > 50) 
  431.               report_error ("%d is excessive, did you really mean this?! (type %n -h for help)\n", option.size);
  432.             break; 
  433.           }       
  434.         case 'S':               /* Generate switch statement output, rather than lookup table. */
  435.           { 
  436.             SET_OPTION (option, SWITCH);
  437.             break;
  438.           }
  439.         case 't':               /* Enable the TYPE mode, allowing arbitrary user structures. */
  440.           { 
  441.             SET_OPTION (option, TYPE);
  442.             break;
  443.           }
  444.         case 'T':               /* Don't print structure definition. */
  445.           {
  446.             SET_OPTION (option, NOTYPE);
  447.             break;
  448.           }
  449.         case 'v':               /* Print out the version and quit. */
  450.           report_error ("%n: version %s\n%e%a\n", version_string, usage);
  451.         default: 
  452.           report_error ("%e%a", usage);
  453.         }
  454.     }
  455.  
  456.         /**
  457.         ***  Open the keyword file. If it can't be opened, then
  458.         ***  report an error
  459.         **/
  460.  
  461.     if ( argv[optind] && ! ( KeyFile = fopen( argv[optind], "r" ) ) )
  462.         report_error( "unable to read key word file %s\n%e%a", argv[optind], usage );
  463.  
  464.         /**
  465.         ***  If there are still arguments left over, this is
  466.         ***  an error.
  467.         **/
  468.  
  469.     if ( ++optind < argc ) 
  470.         report_error( "extra trailing arguments to %n\n%e%a", usage );
  471. }
  472.  
  473.  
  474.     /***********************************************************************\
  475.     *                                                                        *
  476.     * name:        print_options                                                *
  477.     *                                                                        *
  478.     * descr:    Output command-line options.                                *
  479.     *                                                                        *
  480.     \***********************************************************************/
  481.  
  482.  
  483. void print_options()
  484. { 
  485.     int i;
  486.  
  487.     printf( "/* Command-line: ");
  488.  
  489.     for (i = 0; i < option.argument_count; i++ ) 
  490.         printf( "%s ", option.argument_vector[i] );
  491.    
  492.     printf( " */\n\n" );
  493. }
  494.